-- @Author: 作者QQ381990860
-- @Date:   2021-10-15 11:42:07
-- @Last Modified by:   作者QQ381990860
-- @Last Modified time: 2022-09-12 22:37:12

local 地图处理类 = class()
function 地图处理类:初始化()
 self.MapID={6001,6002,6003,4131,4132,4133,3131,3132,5135,5134,1125,1004,1005,1006,1007,1008,1090,5131,1501,1504,1214,1221,1920,
               1505,1511,1506,1503,1507,1508,1509,1524,1532,1537,1126,1092,1142,1514,1174,1177,1178,1179,1180,1181,1182,1183,1186,
                1187,1188,1189,1190,1191,1192,1091,1111,1070,1135,1173,1131,1512,1513,1146,1201,1202,1203,1204,1110,1140,1122,1127,
                1128,1129,1130,1001,1198,1002,1193,1116,1117,1118,1119,1120,1121,1112,1141,1147,1054,1043,1143,1137,1134,1150,1101,
                1144,1145,1123,1124,1040,1226,1208,1502,1523,1526,1525,1527,1534,1009,1028,1029,1020,1017,1022,1030,1528,1132,1133,
                1138,1139,1205,1154,1228,1156,1103,1209,1227,1235,1042,1041,1210,1211,1242,1232,1207,1229,1233,1876,1114,1231,1218,
                1016,1033,1024,1026,1044,1400,1197,1113,1095,1083,1085,1003,1093,1875,1825,1815,1845,1835,1865,1216,1019,1241,1380,
                1251,1250,1249,1257,1252,1217,11351,11352,11353,11354,11355,2000,2001,20002,20003,20004,70930,70940,70950,70960,70970,70980,100111}

 self.MapData={}
    __gge.print(false,7,"-------------------------------------------------------------------------\n")
    __gge.print(true,7,("地图配置脚本\t\t-->"))
    for n=1,#self.MapID do
        self.MapData[self.MapID[n]]={编号=self.MapID[n],单位组={},摆摊人数=0,假人=0,玩家={},--}
        坐标=table.loadstring(__gge.readfile(ServerDirectory.."map//"..self.MapID[n]..".map"))}
    end
    self.MapData[12341]={编号=12341,单位组={},摆摊人数=0,假人=0,玩家={},--}
        坐标=table.loadstring(__gge.readfile(ServerDirectory.."map//12341.map"))}

       self.MapData[7099]={编号=7099,单位组={},摆摊人数=0,假人=0,玩家={},--}
        坐标=table.loadstring(__gge.readfile(ServerDirectory.."map//1131.map"))}
        self.MapData[70930]={编号=70930,单位组={},摆摊人数=0,假人=0,玩家={},--}
        坐标=table.loadstring(__gge.readfile(ServerDirectory.."map//1131.map"))}
        self.MapData[70940]={编号=70930,单位组={},摆摊人数=0,假人=0,玩家={},--}
        坐标=table.loadstring(__gge.readfile(ServerDirectory.."map//1131.map"))}
        self.MapData[70950]={编号=70930,单位组={},摆摊人数=0,假人=0,玩家={},--}
        坐标=table.loadstring(__gge.readfile(ServerDirectory.."map//1131.map"))}
        self.MapData[70960]={编号=70930,单位组={},摆摊人数=0,假人=0,玩家={},--}
        坐标=table.loadstring(__gge.readfile(ServerDirectory.."map//1131.map"))}
        self.MapData[70970]={编号=70930,单位组={},摆摊人数=0,假人=0,玩家={},--}
        坐标=table.loadstring(__gge.readfile(ServerDirectory.."map//1131.map"))}
        self.MapData[70980]={编号=70930,单位组={},摆摊人数=0,假人=0,玩家={},--}
        坐标=table.loadstring(__gge.readfile(ServerDirectory.."map//1131.map"))}

        self.MapData[7100]={编号=7100,单位组={},摆摊人数=0,假人=0,玩家={},--}
        坐标=table.loadstring(__gge.readfile(ServerDirectory.."map//1122.map"))}

        self.MapData[7101]={编号=7101,单位组={},摆摊人数=0,假人=0,玩家={},--}
        坐标=table.loadstring(__gge.readfile(ServerDirectory.."map//11355.map"))}

        self.MapData[7102]={编号=7102,单位组={},摆摊人数=0,假人=0,玩家={},--}
        坐标=table.loadstring(__gge.readfile(ServerDirectory.."map//1001.map"))}

        self.MapData[7103]={编号=7103,单位组={},摆摊人数=0,假人=0,玩家={},--}
        坐标=table.loadstring(__gge.readfile(ServerDirectory.."map//1511.map"))}

        self.MapData[7104]={编号=7104,单位组={},摆摊人数=0,假人=0,玩家={},--}
        坐标=table.loadstring(__gge.readfile(ServerDirectory.."map//1124.map"))}
    for i=0,92 do
      self.MapData[i+7000]={编号=i+7000,单位组={},摆摊人数=0,假人=0,玩家={},--}
        坐标=table.loadstring(__gge.readfile(ServerDirectory.."map//1009.map"))}
    end
    __gge.print(false,7,"\t\t\t[")
    __gge.print(false,10,"成功")
    __gge.print(false,7,"]\n")
end

function 地图处理类:Randomloadtion(IDX)
    local n,_x,_y,x,y = 0,40,40,0,0
        repeat
            x = math.random(MapData[IDX].宽)
            y = math.random(MapData[IDX].高)
            n=n+1
        until (self.MapData[IDX].坐标[x] and self.MapData[IDX].坐标[x][y]) or n>250

    if n>200 then
        return {x=_x,y=_y}
    end
    return {x=x,y=y}
end

local MpsExist =function(user,num)
  if MapData[user.地图].传送圈 then
      for k,v in pairs(MapData[user.地图].传送圈) do
         if v == num and 取两点距离(user.角色.地图数据,{x=TransferData[num].x*20,y=TransferData[num].y*20} ) < 300 then
              return true
         end
      end
  end
  return false
end

function 地图处理类:数据处理(内容)----------------------------------------------------完成-------
    if 内容 ==nil or 内容.数字id== nil or 玩家数据[内容.数字id] == nil or 玩家数据[内容.数字id].摆摊  then
        return 0
    end
    if 内容.序号 == 1 then
        self:玩家移动请求(内容.数字id, 内容.文本)
    elseif 内容.序号 == 2 then
        self:玩家坐标刷新(内容.数字id, 内容)
   elseif 内容.序号 == 3 then

        if MpsExist(玩家数据[内容.数字id],内容.参数) and  TransferData[内容.参数] then
            if 玩家数据[内容.数字id].队伍==0 or 玩家数据[内容.数字id].队长 then
             self:跳转处理(内容.数字id,{TransferData[内容.参数].目标,TransferData[内容.参数].x2*20,TransferData[内容.参数].y2*20})
           end
        end
     elseif 内容.序号 == 4 then
         self:玩家移动请求(内容.数字id, 内容.文本,1)
     elseif 内容.序号 == 5 then
         tchs()
            return
    elseif 内容.序号 == 6 then
        local dzlc={"静立","招呼","行礼","舞蹈","跑步","挨打","死亡","悲伤","攻击","发怒","施法","休息"}
        if 内容.参数 +0 > 12 then
           return
        else
            玩家数据[内容.数字id].动作=dzlc[内容.参数 +0]
        end
        发送数据(玩家数据[内容.数字id].连接id,2001,玩家数据[内容.数字id].动作)
        self:MapSend(内容.数字id, 1022,{id=内容.数字id,动作=玩家数据[内容.数字id].动作},玩家数据[内容.数字id].地图)
    end
end

function 地图处理类:跳转处理(id,消息)-------------------------------------------------完成--------
    if 玩家数据[id].战斗 ~= 0  then
        return 0
    end
 if 玩家数据[id].队伍==0 then
    self:指定跳转(id,消息[1],消息[2],消息[3])
  else
    for n=1,#队伍数据[玩家数据[id].队伍].队员数据 do
      self:指定跳转(队伍数据[玩家数据[id].队伍].队员数据[n],消息[1],消息[2],消息[3])
      end
   end
end

function 地图处理类:Jump(id, 地图编号, 地图x, 地图y, 战斗)
    if 玩家数据[id].战斗 ~= 0 and 战斗 == nil then
        return 0
    end
    if 玩家数据[id].队伍 == 0 then
        self:指定跳转(id, 地图编号, 地图x * 20, 地图y * 20)
    else
        for n = 1, #队伍数据[玩家数据[id].队伍].队员数据 do
            self:指定跳转(队伍数据[玩家数据[id].队伍].队员数据[n], 地图编号, 地图x * 20, 地图y * 20)
        end
    end
end

function 地图处理类:指定跳转(id,地图编号,地图x,地图y)----------------------------------完成------
 self:移除玩家(玩家数据[id].地图,id)
 玩家数据[id].地图=地图编号
 if 地图编号==1501 or 地图编号==1001 or 地图编号==1070 or 地图编号==1092  or 地图编号==1040 or 地图编号==1226 or 地图编号==1208 then
   玩家数据[id].角色.传送地图=地图编号
 end
 if 地图x > MapData[地图编号].宽*20 or 地图y > MapData[地图编号].高*20 then
   发送数据(玩家数据[id].连接id,7,string.format("%s跳转地图%s失败,坐标x%d坐标y%d请将错误记录发给GM",MapData[玩家数据[id].地图].名称,MapData[地图编号].名称,地图x,地图y))
   发送数据(玩家数据[id].连接id,9,string.format("%s跳转地图%s失败,坐标x%d坐标y%d请将错误记录发给GM",MapData[玩家数据[id].地图].名称,MapData[地图编号].名称,地图x,地图y))
   return
 end
 玩家数据[id].角色.地图数据.编号=地图编号
 玩家数据[id].角色.地图数据.x=地图x
 玩家数据[id].角色.地图数据.y=地图y
 self:加入玩家(id)
 self.发送消息 = {x = 地图x,y = 地图y}
 发送数据(玩家数据[id].连接id,2014,self.发送消息)
end

function 地图处理类:玩家移动请求(id, 内容, 队伍)---------------------------------------完成------
    if 玩家数据[id] == nil then
        return 0
    end
    if 队伍 == nil and 玩家数据[id].队伍 ~= 0 and 玩家数据[id].队长 == false then
        return 0
    end
    玩家数据[id].动作=nil
    发送数据(玩家数据[id].连接id,1002,内容)
    self:发送玩家(id,玩家数据[id].地图)
    self:MapSend(id,1005,{数据 = 内容,id = id},玩家数据[id].地图)
    if 玩家数据[id].队伍 ~= 0 and 玩家数据[id].队长 then
        local 临时文本 = 分割文本(内容, "*-*")
        for n = 2, #队伍数据[玩家数据[id].队伍].队员数据 do
      if 玩家数据[队伍数据[玩家数据[id].队伍].队员数据[n]] then
                发送数据(玩家数据[队伍数据[玩家数据[id].队伍].队员数据[n]].连接id, 1020, {
                    目标 = 内容,
                    x = 临时文本[1],
                    y = 临时文本[2],
                    编号 = n})
       end
        end
    end
end

function 地图处理类:添加单位(数据组)
 local lsbh =#self.MapData[数据组.地图编号].单位组+1
 self.MapData[数据组.地图编号].单位组[lsbh]=
 {名称=数据组.名称,
 模型=数据组.造型,
 方向=数据组.方向,
 X=数据组.坐标.x,
 Y=数据组.坐标.y,
 战斗=数据组.战斗,
 id=数据组.id,
 副本=数据组.副本,
 染色组=数据组.染色组,
 染色方案=数据组.染色方案,
 武器数据=数据组.武器,
 锦衣数据=数据组.锦衣数据,
 事件=数据组.事件 or 数据组.类型 ,
 编号 =lsbh,
 任务id=数据组.任务id,
 时间 = 数据组.起始,
 第一次 = 数据组.第一次,
 第二次 = 数据组.第二次,
 第三次 = 数据组.第三次,
 称谓 = 数据组.称谓}

 self:发送指定地图单位(数据组.地图编号,lsbh)
end
function 地图处理类:添加边境单位(数据组)

 local lsbh =#self.MapData[数据组.地图编号].单位组+1
 self.MapData[数据组.地图编号].单位组[lsbh]=
 {
 名称=数据组.名称,
 模型=数据组.造型,
 方向=数据组.方向,
 X=数据组.坐标.x,
 Y=数据组.坐标.y,
 战斗=数据组.战斗,
 id=数据组.id,
 副本=数据组.副本,
 事件=数据组.类型 ,
 编号 =lsbh,
 真假 = 数据组.真假,
 任务id=数据组.任务id,
 称谓 = 数据组.称谓
 }
 self:发送指定地图单位(数据组.地图编号,lsbh)
 end
function 地图处理类:移除单位(地图,移除id)
 local 标记单位=0
 地图=地图+0
 for n, v in pairs(self.MapData[地图].单位组) do
   if self.MapData[地图].单位组[n].任务id==移除id then
     self.MapData[地图].单位组[n]=nil
     标记单位=n
     break
   end
 end
 if 标记单位~=0 then
      for n, v in pairs(self.MapData[地图].玩家) do
        if 玩家数据[n] then
          发送数据(玩家数据[n].连接id,1018,移除id)
         end
      end
   end
end

function 地图处理类:发送地图单位(id,地图)
  if  地图~=3131 and 地图~=3132 then
    发送数据(玩家数据[id].连接id,1019,self.MapData[地图].单位组)
  else
     self.发送单位信息={}
     for n, v in pairs(self.MapData[地图].单位组) do
        if self.MapData[地图].单位组[n]~=nil and self.MapData[地图].单位组[n].副本==玩家数据[id].副本 then
           self.发送单位信息[n]=self.MapData[地图].单位组[n]
        end
     end
     发送数据(玩家数据[id].连接id,1019,self.发送单位信息)
    end
end

function 地图处理类:发送指定地图单位(地图,编号)
 for n, v in pairs(self.MapData[地图].玩家) do
     if 玩家数据[n]~=nil and self.MapData[地图].单位组[编号]~=nil and  (self.MapData[地图].单位组[编号].副本==nil or self.MapData[地图].单位组[编号].副本==玩家数据[n].副本) then
        发送数据(玩家数据[n].连接id,1017,self.MapData[地图].单位组[编号])
       end
   end
end

function 地图处理类:升级事件(id)
    self:MapSend(id,1007,id,玩家数据[id].地图)
end

function 地图处理类:玩家坐标刷新(id, 内容)
    内容.x = 内容.参数
    内容.y = 内容.文本 + 0
    if 内容 == nil or 内容 == "" or 玩家数据[id].地图 ~=内容.编号+0  then
        return 0
    end
    if 玩家数据[id].队伍 ~= 0 and 玩家数据[id].队长 == false then
        self.队员编号 = 0
        for n = 1, #队伍数据[玩家数据[id].队伍].队员数据 do
            if 队伍数据[玩家数据[id].队伍].队员数据[n] == id then
                self.队员编号 = n
            end
        end
        if self.队员编号 ~= 0 then
            if  not (取两点距离(内容, 玩家数据[队伍数据[玩家数据[id].队伍].队员数据[1]].角色.地图数据) >= (self.队员编号 - 1) * 50) then
                return 0
            end
        end
    end
    玩家数据[id].角色.地图数据.x = 内容.x
    玩家数据[id].角色.地图数据.y = 内容.y

    if 玩家数据[id].队伍 ~= 0 and 玩家数据[id].队长 then
        -- Nothing
    elseif 玩家数据[id].队伍 ~= 0 then
        self.队员编号 = 0
        for n = 1, #队伍数据[玩家数据[id].队伍].队员数据 do
            if 队伍数据[玩家数据[id].队伍].队员数据[n] == id then
                self.队员编号 = n
            end
        end
        if self.队员编号 ~= 0 and 取两点距离(内容, 玩家数据[队伍数据[玩家数据[id].队伍].队员数据[1]].角色.地图数据) >= (self.队员编号 - 1) * 50 then
            self:玩家移动请求(id, 内容.x .. "*-*" .. 内容.y)
        end
    end
    self:发送玩家(id, 玩家数据[id].地图)

    if 天罚数据表[id] ~= nil and 天罚数据表[id] >= 3 and math.random(100) <= 5 then
        角色处理类:接受天罚(玩家数据[id])
    elseif MapData[玩家数据[id].地图].怪物 ~= nil and (玩家数据[id].队伍 == 0 or 玩家数据[id].队长) and 玩家数据[id].遇怪时间.间隔 <= os.time() - 玩家数据[id].遇怪时间.起始 and 玩家数据[id].战斗 == 0  and 角色处理类:GetTaskID(玩家数据[id],"摄妖香") == 0 then
          玩家数据[id].遇怪时间.起始 = os.time()
          战斗准备类:创建战斗(id, 100001, 0)
  else
      for n, v in pairs(玩家数据[id].角色.任务数据) do
          if  任务数据[v]   then
                if 任务数据[v].类型 =="师门" and self:取门派地图(id) and 任务数据[v].分类 == 4 and 任务数据[v].战斗 <= os.time() - 任务数据[v].起始 and 任务数据[v].次数 > 0 then
                    任务数据[v].起始 = os.time()
                      战斗准备类:进入处理(id, 100014, "66", v)
                      break
                elseif 任务数据[v].类型 =="押镖" and 玩家数据[id].押镖时间.间隔 <= os.time() - 玩家数据[id].押镖时间.起始 and 玩家数据[id].战斗 == 0 then
                      战斗准备类:进入处理(id, 100050, "66", v)
                       break
                elseif 任务数据[v].类型 =="除暴安良"and 任务数据[v].分类 == 5 and  玩家数据[id].遇怪时间.间隔 <= os.time() - 玩家数据[id].遇怪时间.起始 then
                     玩家数据[id].遇怪时间.起始 = os.time()
                      战斗准备类:进入处理(id,100002,"66",v,"除暴安良")
                      break
                elseif LinkTask[任务数据[v].类型] and LinkTask[任务数据[v].类型]["进程"..任务数据[v].进程][1] == "遇怪战斗" and 任务数据[v].Map==玩家数据[id].地图 and  玩家数据[id].遇怪时间.间隔 <= os.time() - 玩家数据[id].遇怪时间.起始  then
                      玩家数据[id].遇怪时间.起始 = os.time()
                      战斗准备类:LoadMonster(玩家数据[id],v,LinkTask[任务数据[v].类型].怪物["进程"..任务数据[v].进程],2)
                end
          else
                玩家数据[id].角色.任务数据[n]=nil
          end
      end
  end
end

function 地图处理类:NPC更改战斗(地图,更改id)
 地图=地图+0
      for n, v in pairs(self.MapData[地图].玩家) do
        if 玩家数据[n] then
          发送数据(玩家数据[n].连接id,1024,更改id)
         end
      end
end

function 地图处理类:NPC取消战斗(地图,更改id)
 地图=地图+0
      for n, v in pairs(self.MapData[地图].玩家) do
        if 玩家数据[n] then
          发送数据(玩家数据[n].连接id,1025,更改id)
         end
      end
end

function 地图处理类:取迷宫玩家组()
    self.返回玩家组 = {}
    for n = 1, 20 do
        self.临时id = n + 7000
        for i, v in pairs(self.MapData[self.临时id].玩家) do
            if 玩家数据[n] and 玩家数据[n].战斗 == 0 then
                self.返回玩家组[#self.返回玩家组 + 1] = i
            end
        end
    end
    return self.返回玩家组
end

function 地图处理类:重置比武大会玩家()
    比武大会数据 = {}
    for n = 6001, 6003 do
        self.临时id = n
        for i, v in pairs(self.MapData[self.临时id].玩家) do
            玩家数据[i].比武保护期 = 0
            比武大会数据[i] = {奖励 = false,积分 = 0}
            发送数据(v.连接id, 7, "#y/你当前的比武积分为0分")
            发送数据(v.连接id, 7, "#y/每战胜一名玩家可获得5点积分")
        end
    end
end

function 地图处理类:无间炼狱奖励()
    for n, v in pairs(self.MapData[1214].玩家) do
        if 玩家数据[n] ~= nil and   角色处理类:GetTaskID(玩家数据[n],"天机培元丹") ~= 0 then
            self.临时等级 = 玩家数据[n].角色.等级
            self.临时经验 = self.临时等级 * self.临时等级*10
            if 角色处理类:GetTaskID(玩家数据[n],"九霄清心丸") ~= 0 then
                self.临时经验=self.临时经验*2
            end
            角色处理类:添加经验(玩家数据[n],self.临时经验, "挂机经验")
        end
    end
end
function 地图处理类:会员地图()
  for n, v in pairs(self.MapData[8888].玩家) do
    if 玩家数据[n] ~= nil and   玩家数据[n].角色.vip.等级 ~= 0 then
      self.临时等级 = 玩家数据[n].角色.等级
      self.临时经验 = self.临时等级 * self.临时等级*10
            if 玩家数据[n].角色.vip.等级 >= 3 then
                self.临时经验=self.临时经验*2
            end
      角色处理类:添加经验(玩家数据[n],self.临时经验, "挂机经验")
    end
  end
  for n, v in pairs(self.MapData[8889].玩家) do
    if 玩家数据[n] ~= nil and   玩家数据[n].角色.vip.等级 ~= 0 then
      self.临时等级 = 玩家数据[n].角色.等级
      self.临时经验 = self.临时等级 * self.临时等级*10
            if 玩家数据[n].角色.vip.等级 >= 3 then
                self.临时经验=self.临时经验*2
            end
      角色处理类:添加经验(玩家数据[n],self.临时经验, "挂机经验")
    end
  end
  for n, v in pairs(self.MapData[8890].玩家) do
    if 玩家数据[n] ~= nil and   玩家数据[n].角色.vip.等级 ~= 0 then
      self.临时等级 = 玩家数据[n].角色.等级
      self.临时经验 = self.临时等级 * self.临时等级*10
            if 玩家数据[n].角色.vip.等级 >= 3 then
                self.临时经验=self.临时经验*2
            end
      角色处理类:添加经验(玩家数据[n],self.临时经验, "挂机经验")
    end
  end
end

function 地图处理类:单独发送地图单位(地图, 编号, id)
    for n, v in pairs(self.MapData[地图].玩家) do
        if 玩家数据[n] ~= nil and self.MapData[地图].单位组[编号] ~= nil and (self.MapData[地图].单位组[编号].副本 == nil or self.MapData[地图].单位组[编号].副本 == 玩家数据[n].副本) then
            发送数据(玩家数据[n].连接id, 1017, self.MapData[地图].单位组[编号])
        end
    end
end

function 地图处理类:取门派地图(id)
 local 门派巡逻地图={
    大唐官府={1198,1054,1052}
    ,化生寺={1043,1002,1528}
    ,方寸山={1135,1137}
    ,女儿村={1143,1142}
    ,龙宫={1117,1116}
    ,天宫={1111,1112}
    ,普陀山={1140,1141}
    ,五庄观={1146,1147}
    ,魔王寨={1512,1145}
    ,盘丝洞={1513,1144}
    ,阴曹地府={1125,1124,1123,1122}
    ,狮驼岭={1131,1134,1132,1133}
    ,凌波城={1150}
    ,神木林={1138,1154}
    ,花果山={1251}
    ,天机城={1250,1257}
    ,女魃墓={1249,1252}
    ,无底洞={1139,1156}}
    if 玩家数据[id].角色.门派 == "无" then
        return false
    else
        for n = 1, #门派巡逻地图[玩家数据[id].角色.门派] do
            if 玩家数据[id].角色.地图数据.编号 == 门派巡逻地图[玩家数据[id].角色.门派][n] then
                return true
            end
        end
        return false
    end
end

function 地图处理类:置传送(id,m)-------------------------------------------------------------------
 if  角色处理类:取飞行限制(玩家数据[id])  then
   if  (玩家数据[id].角色.门派~="无"  or 玩家数据[id].角色.等级 > 120) and DebugMode == false   then
    发送数据(玩家数据[id].连接id,7,"#Y/少侠等级太高了或者已经加入了门派不能为你传送")
    return false
  elseif  玩家数据[id].队伍~=0 and DebugMode == false then
        发送数据(玩家数据[id].连接id,7,"#Y/请解散队伍在进行传送")
    return false
  end
  local cs
  if m == "方寸山" then
    cs = {1135,100,49}
  elseif m == "女儿村" then
    cs = {1142,19,49}
  elseif m == "神木林" then
    cs = {1138,46,121}
  elseif m == "大唐官府" then
    cs = {1198,128,82}
  elseif m == "化生寺" then
    cs = {1002,30,76}
  elseif m == "阴曹地府" then
    cs = {1122,62,79}
  elseif m == "盘丝洞" then
    cs = {1513,170,40}
  elseif m == "无底洞" then
    cs = {1139,21,113}
  elseif m == "狮驼岭" then
    cs = {1131,102,83}
  elseif m == "魔王寨" then
    cs = {1512,93,32}
  elseif m == "普陀山" then
    cs = {1140,30,23}
  elseif m == "天宫" then
    cs = {1111,187,128}
  elseif m == "凌波城" then
    cs = {1150,9,94}
  elseif m == "五庄观" then
    cs = {1146,30,55}
  elseif m == "龙宫" then
    cs = {1116,69,81}
  elseif m == "花果山" then
    cs = {1251,92,41}
  elseif m == "天机城" then
    cs = {1250,109,53}
  elseif m == "女魃墓" then
    cs = {1249,53,40}
  end
   cs[2]=cs[2]*20
   cs[3]=cs[3]*20
  self:跳转处理(id,cs)
  end
end

function 地图处理类:传送地图玩家(dit)
    for n, v in pairs(self.MapData[dit].玩家) do
         玩家数据[n].角色.称谓.特效=4285922956
        发送数据(玩家数据[n].连接id, 1026,玩家数据[n].角色.称谓)
         if  玩家数据[n].队伍 ~= 0 then
            for p = 1, #队伍数据[玩家数据[n].队伍].队员数据 do
               if 玩家数据[队伍数据[玩家数据[n].队伍].队员数据[p]] then
                玩家数据[队伍数据[玩家数据[n].队伍].队员数据[p]].角色.称谓.特效=4285922956
                发送数据(玩家数据[队伍数据[玩家数据[n].队伍].队员数据[p]].连接id, 1026,玩家数据[队伍数据[玩家数据[n].队伍].队员数据[p]].角色.称谓)
              end
            end
         end
          self:Jump(n, 1001, 378, 160, 1)
    end
end

function 地图处理类:加入玩家(id)
    if 玩家数据[id] == nil then
        return 0
    elseif 玩家数据[id].地图 == nil or self.MapData[玩家数据[id].地图].玩家 == nil then
        return 0
    end
    玩家数据[id].遇怪时间 = {
        起始 = os.time(),
        间隔 = math.random( 2)
    }
        玩家数据[id].押镖时间 = {
        起始 = os.time(),
        间隔 = math.random(15, 30)
    }
    self.MapData[玩家数据[id].地图].玩家[id] ={}
    self.发送消息 = {
        编号 = 玩家数据[id].地图,
        名称 = MapData[玩家数据[id].地图].名称,
        传送圈 =self:LoadTransfer(玩家数据[id]),
        地图数据=玩家数据[id].角色.地图数据
    }
    发送数据(玩家数据[id].连接id,1001,self.发送消息)
    self:发送玩家(id, 玩家数据[id].地图)
    self:发送地图单位(id, 玩家数据[id].地图)
    self:LoadNpc(玩家数据[id])
end

function 地图处理类:LoadTransfer(user)
  local msg={}
 if MapData[user.地图].传送圈   then
    for k,v in pairs(MapData[user.地图].传送圈) do
        if TransferData[v] then
                msg[k]={TransferData[v].x,TransferData[v].y,v}
         else
            print(string.format("编号%d传送圈不存在请检查数据表",v))
        end
    end
     return msg
  end
end

function 地图处理类:LoadNpc(user)
  local msg={}
 if MapData[user.地图].NPC   then
    for k,v in pairs(MapData[user.地图].NPC) do
        if NpcData[v] then
                msg[k]={编号=v,名称=NpcData[v].名称,模型=NpcData[v].模型,方向=NpcData[v].方向,事件=NpcData[v].事件,称谓=NpcData[v].称谓,X=NpcData[v].X,Y=NpcData[v].Y,}
         else
            print(string.format("编号%dNPC不存在请检查数据表",v))
        end
    end
    发送数据(user.连接id,1010,msg)
  end
end

function 地图处理类:更新摊位(id, 名称, 地图)
    self:MapSend(id,20009, {id = id,名称 = 名称},地图)
end

function 地图处理类:更改队长(id, 队长)
    local 发送内容 ={}
    if 队长 then
        self.发送序号 = 5004
        发送内容 ={id=id,动画=队伍数据[玩家数据[id].队伍].队标}
    else
        self.发送序号 = 5005
        发送内容 ={id=id}
    end
    self:MapSend(id,self.发送序号,发送内容,玩家数据[id].地图)
end

function 地图处理类:发送玩家(id, 地图)
    if self.MapData[地图] == nil then
        发送数据(玩家数据[id].连接id, 7, "#y/地图数据错误，错误代号7001")
        return 0
    end
    for n, v in pairs(self.MapData[地图].玩家) do
        if n ~= id and 玩家数据[n] ~= nil and self:取同一地图(id, n, 地图) then
               if not self.MapData[地图].玩家[id][n] then
                发送数据(玩家数据[id].连接id,1004,角色处理类:获取地图数据(玩家数据[n],n))
                发送数据(玩家数据[n].连接id,1004,角色处理类:获取地图数据(玩家数据[id],id))
                self.MapData[地图].玩家[id][n]=true
                 self.MapData[地图].玩家[n][id]=true
                if 玩家数据[n].战斗 ~= 0 then
                发送数据(玩家数据[id].连接id, 1012, n)
                end
               end
        elseif self.MapData[地图].玩家[id][n] then
                   self.MapData[地图].玩家[id][n]=nil
                 self.MapData[地图].玩家[n][id]=nil
            发送数据(玩家数据[n].连接id,1008,id)
            发送数据(玩家数据[id].连接id,1008,n)
        end
    end
end
function 地图处理类:刷新光环显示(id,地图,光环)
  for n, v in pairs(self.MapData[地图].玩家) do
    if n ~= id and 玩家数据[n] ~= nil and self:取同一地图(id, n, 地图) then
       发送数据(玩家数据[n].连接id,6814,{id=id,光环=光环})
    end
  end
  发送数据(玩家数据[id].连接id,6813,光环)
end

function 地图处理类:取同一地图(id, id1, 地图)
    if   取两点距离(玩家数据[id].角色.地图数据,玩家数据[id1].角色.地图数据)>= 600 then
          return false
    elseif 地图 == 5135 then
        if 玩家数据[id1].角色.门派 ~= 玩家数据[id].角色.门派 then
            return false
        end
    elseif 地图 == 1875 or 地图 == 1865 or 地图 == 1855 or 地图 == 1845 or 地图 == 1835 or 地图 == 1825 or 地图 == 1815 then
        if 玩家数据[id].帮派进入方式 == 1 then
            if 玩家数据[id].角色.帮派 ~= 玩家数据[id1].角色.帮派 then
                return false
            else
                return true
            end
        end
    elseif 地图 == 3131 or 地图 == 3132 or 地图 == 4131 or 地图 == 4132 or 地图 == 4133 then
        return 玩家数据[id1].副本 == 玩家数据[id].副本 and true or false
    end
    return true
end

function 地图处理类:MapSend(id, 序号, 内容 )
    local 地图 =玩家数据[id].地图
    for n, v in pairs(self.MapData[地图].玩家) do
        if n ~= id and 玩家数据[n] ~= nil and self:取同一地图(id, n, 地图) then
            发送数据(玩家数据[n].连接id, 序号, 内容)
        end
    end
end

function 地图处理类:摊位重复(id, 地图)
    for n, v in pairs(self.MapData[玩家数据[id].地图].玩家) do
        if n ~= id and 玩家数据[n] ~= nil and self:取同一地图(id, n, 玩家数据[id].地图) and 玩家数据[n].摆摊 ~= nil and self:取距离范围(id, n, 50) then
            return true
        end
    end
    return false
end

function 地图处理类:取距离范围(id, id1, 距离)
    if 玩家数据[id] == nil or 玩家数据[id1] == nil or 玩家数据[id].地图 ~= 玩家数据[id1].地图 then
        return false
    elseif 取两点距离(玩家数据[id].角色.地图数据, 玩家数据[id1].角色.地图数据) <= 距离 then
        return true
    else
        return false
    end
end

function 地图处理类:发送当前消息(id, 内容)
      local tx =""
    local ss=tostring(id)
    for i = 1, string.len(ss) do
        tx=tx.."#lhtxb"..string.sub(ss,i,i).."/"
    end
    self.组合消息 = "#dq/#w/[" ..玩家数据[id].角色.名称 .."]#w/("..tx .."#w/)"..内容
    发送数据(玩家数据[id].连接id,21,self.组合消息)
    self:MapSend(id,1015,{消息 = 内容,id = 玩家数据[id].id},玩家数据[id].地图)
    self:MapSend(id,21, self.组合消息,玩家数据[id].地图)
end

function 地图处理类:更改战斗(id, 战斗)
    if 战斗 then
        self.发送序列 = 1012
    else
        self.发送序列 = 1013
    end
     self:MapSend(id,self.发送序列,id,玩家数据[id].地图)
end

function 地图处理类:更改称谓(地图, user, 称谓)
     角色处理类:刷新战斗属性(user,1)
     self:MapSend(user.id,1009,{称谓 = 称谓,id = user.id,effects=user.角色.称谓.effects},地图)
end

function 地图处理类:移除玩家(地图, id)
    if self.MapData[地图].玩家 == nil then
        return 0
    end
    self.MapData[地图].玩家[id] = nil
    self:MapSend(id,1008,id,地图)
end

return 地图处理类